/**
 * 全局用户状态管理器
 * 确保用户登录状态在所有页面间保持一致
 */

class UserManager {
    constructor() {
        this.currentUser = null;
        this.isLoggedIn = false;
        this.listeners = [];
        this.checkInterval = null;
        
        // 初始化时检查用户状态
        this.checkUserStatus();
        
        // 设置定期检查（每30秒检查一次）
        this.startPeriodicCheck();
        
        // 监听页面可见性变化
        document.addEventListener('visibilitychange', () => {
            if (!document.hidden) {
                this.checkUserStatus();
            }
        });
        
        // 监听存储变化（跨标签页同步）
        window.addEventListener('storage', (e) => {
            if (e.key === 'user_session_sync') {
                this.checkUserStatus();
            }
        });
    }
    
    /**
     * 检查用户登录状态
     */
    async checkUserStatus() {
        try {
            const response = await fetch('/api/user-status');
            const data = await response.json();
            
            const wasLoggedIn = this.isLoggedIn;
            const previousUser = this.currentUser;
            
            this.isLoggedIn = data.logged_in;
            this.currentUser = data.logged_in ? data.username : null;
            
            // 如果状态发生变化，通知所有监听器
            if (wasLoggedIn !== this.isLoggedIn || previousUser !== this.currentUser) {
                this.notifyListeners();
                // 同步到其他标签页
                this.syncToOtherTabs();
            }
            
        } catch (error) {
            console.error('检查用户状态失败:', error);
            // 网络错误时不改变当前状态
        }
    }
    
    /**
     * 用户登录
     */
    async login(username, password) {
        try {
            const formData = new FormData();
            formData.append('username', username);
            formData.append('password', password);
            
            const response = await fetch('/api/login', {
                method: 'POST',
                body: formData
            });
            
            const data = await response.json();
            
            if (data.success) {
                this.isLoggedIn = true;
                this.currentUser = username;
                this.notifyListeners();
                this.syncToOtherTabs();
                // 立即检查服务器状态确保同步
                setTimeout(() => this.checkUserStatus(), 100);
            }
            
            return data;
        } catch (error) {
            console.error('登录失败:', error);
            return { success: false, message: '网络错误，请重试' };
        }
    }
    
    /**
     * 用户登出
     */
    async logout() {
        try {
            const response = await fetch('/logout');
            const data = await response.json();
            
            if (data.success) {
                this.isLoggedIn = false;
                this.currentUser = null;
                this.notifyListeners();
                this.syncToOtherTabs();
                // 立即检查服务器状态确保同步
                setTimeout(() => this.checkUserStatus(), 100);
            }
            
            return data;
        } catch (error) {
            console.error('登出失败:', error);
            return { success: false, message: '网络错误，请重试' };
        }
    }
    
    /**
     * 添加状态变化监听器
     */
    addListener(callback) {
        this.listeners.push(callback);
        // 立即调用一次，确保监听器获得当前状态
        callback(this.isLoggedIn, this.currentUser);
    }
    
    /**
     * 监听用户状态变化（简化接口）
     */
    onUserChange(callback) {
        this.addListener((isLoggedIn, username) => {
            callback({
                isLoggedIn,
                username
            });
        });
    }
    
    /**
     * 检查状态（简化接口）
     */
    async checkStatus() {
        await this.checkUserStatus();
        return {
            isLoggedIn: this.isLoggedIn,
            username: this.currentUser
        };
    }
    
    /**
     * 移除状态变化监听器
     */
    removeListener(callback) {
        const index = this.listeners.indexOf(callback);
        if (index > -1) {
            this.listeners.splice(index, 1);
        }
    }
    
    /**
     * 通知所有监听器状态变化
     */
    notifyListeners() {
        this.listeners.forEach(callback => {
            try {
                callback(this.isLoggedIn, this.currentUser);
            } catch (error) {
                console.error('监听器回调执行失败:', error);
            }
        });
    }
    
    /**
     * 同步状态到其他标签页
     */
    syncToOtherTabs() {
        try {
            localStorage.setItem('user_session_sync', Date.now().toString());
        } catch (error) {
            // 忽略localStorage错误
        }
    }
    
    /**
     * 开始定期检查
     */
    startPeriodicCheck() {
        // 每30秒检查一次用户状态
        this.checkInterval = setInterval(() => {
            this.checkUserStatus();
        }, 30000);
    }
    
    /**
     * 停止定期检查
     */
    stopPeriodicCheck() {
        if (this.checkInterval) {
            clearInterval(this.checkInterval);
            this.checkInterval = null;
        }
    }
    
    /**
     * 获取当前用户信息
     */
    getCurrentUser() {
        return {
            isLoggedIn: this.isLoggedIn,
            username: this.currentUser
        };
    }
    
    /**
     * 销毁管理器
     */
    destroy() {
        this.stopPeriodicCheck();
        this.listeners = [];
    }
}

// 创建全局用户管理器实例
window.userManager = new UserManager();

// 导出用户管理器
if (typeof module !== 'undefined' && module.exports) {
    module.exports = UserManager;
}